home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Tools - Objects / MacApp / MacApp 2.0 CD Release / MacApp 2.0 (Many Libraries) / Examples / Calc / UCalc.p < prev    next >
Encoding:
Text File  |  1990-03-27  |  35.3 KB  |  1,027 lines  |  [TEXT/MPS ]
  1. {[a-,body+,h-,o=100,r+,rec+,t=4,u+,#+,j=20/57/1$,n-]}
  2. { UCalc.p }
  3. { Copyright © 1986-1990 by Apple Computer, Inc. All rights reserved.}
  4.  
  5. { This MacApp sample implements a simple spreadsheet }
  6. { This version, created Christmas Day 1989 by Larry Tesler, uses  
  7.     classes TPrimaryScroller and TSecondaryScroller in USynchScroller
  8.     [instead of defining its own TCalcScroller and four AutoScroll methods]
  9.     to achieve synchronous scrolling [instead of near-synchronous scrolling]
  10.     and to enable auto-scrolling during column resizing. }
  11.  
  12. UNIT UCalc;
  13.  
  14.     INTERFACE
  15.  
  16.         USES
  17.             { • MacApp }
  18.             UMacApp,
  19.  
  20.             { • Building Blocks }
  21.             UPrinting, UGridView, UTEView,
  22.  
  23.             { • Required for this unit's interface }
  24.             Sane,
  25.  
  26.             { • Implementation use }
  27.             ToolUtils, Fonts, Packages
  28.  
  29.             {$IFC qNeedsROM128K}
  30.             , PrintTraps
  31.             {$ELSEC}
  32.             , Printing                                    { Needed because we override printing
  33.                                                          commands }
  34.             {$ENDC}
  35.  
  36.             { • Other Libraries }
  37.             , CalcUtilities, UGrabberTracker, USynchScroller;
  38.  
  39.         CONST
  40.  
  41.             kMaxRows            = 120;                    { Maximum row number }
  42.             kMaxColumns         = 64;                    { Maximum column number }
  43.             kMaxValueLength     = 24;                    { Max. length of a value as a string }
  44.  
  45.             kSignature            = 'SS12';                { Application signature. }
  46.             kFileType            = 'SF12';                { Data file type. }
  47.  
  48.             kCalcWindowType     = 1001;                 { Resource id of the spreadsheet window }
  49.  
  50.         TYPE
  51.  
  52.             CalcMode            = (Manual, Automatic);
  53.  
  54.             RowNumber            = 0..kMaxRows;            { Zero indicates no row. }
  55.             ColumnNumber        = 0..kMaxColumns;
  56.  
  57.             ValueType            = Extended;
  58.             DiskValueType        = Double;                { Extendeds are for internal use only}
  59.             ValueString         = STRING[kMaxValueLength];
  60.  
  61.             ValueFormat         = DecForm;                { Have SANE display numeric values in
  62.                                                          decimal }
  63.  
  64.             KindOfCell            = (EmptyCell, ValueCell, TextCell, ErrorCell);
  65.  
  66.             EvalResult            = (NoError, MissingRightParen, SelfReference, ErrorCellReference,
  67.                                    BadNumber, IllegalCharacter, BadCellReference, GarbageAtEnd);
  68.  
  69.             TypeOfSelection     = (NoSelection, CellSelection, RowSelection, ColumnSelection,
  70.                                    AllSelection);
  71.  
  72.             TypeOfStyle         = (NoStyle, General, DecimalStyle, NoDecimal, Scientific,
  73.                                    UnknownStyle);
  74.  
  75.             FormatRecord        = RECORD
  76.                 fStyle:             TypeOfStyle;
  77.                 fDigits:            0..255;
  78.                 fJustification:     SignedByte;
  79.                 fFontNumber:        0..255;
  80.                 fFontSize:            0..255;
  81.                 fFontStyle:         Style;
  82.                 END;
  83.             FormatPtr            = ^FormatRecord;
  84.  
  85.             CalcDocDiskInfo     = RECORD                { This is the first record in the file }
  86.                 dimensions:         Rect;
  87.                 CalcMode:            CalcMode;
  88.                 allocatedCells:     INTEGER;
  89.                 allocatedRows:        INTEGER;
  90.                 allocatedColumns:    INTEGER;
  91.                 selectionType:        TypeOfSelection;
  92.                 editRow:            RowNumber;
  93.                 editColumn:         ColumnNumber;
  94.                 END;
  95.  
  96.             RowDiskInfo         = RECORD                { Info about the document's rows }
  97.                 number:             INTEGER;
  98.                 END;
  99.  
  100.             ColumnDiskInfo        = RECORD                { Info about the document's columns }
  101.                 number:             INTEGER;
  102.                 format:             FormatRecord;
  103.                 width:                INTEGER;
  104.                 END;
  105.  
  106.             CellDiskInfo        = RECORD                { The document's cells }
  107.             { row/column coordinate read/written separately }
  108.                 kind:                KindOfCell;
  109.                 error:                EvalResult;
  110.                 value:                DiskValueType;
  111.                 noOfReferences:     INTEGER;
  112.                 formula:            Str255;
  113.                 END;
  114.  
  115.             ScrapInfoRecord     = RECORD
  116.                 selection:            Rect;
  117.                 noOfCells:            INTEGER;
  118.                 END;
  119.  
  120.             CellScrapInfo        = RECORD
  121.             { row/column coordinate read/written separately }
  122.             { cell length read/written separately }
  123.                 format:             FormatRecord;
  124.                 formula:            Str255;
  125.                 END;
  126.  
  127. {--------------------------------------------------------------------------------------------------}
  128.             TCalcApplication    = OBJECT (TApplication)
  129.  
  130.                 PROCEDURE TCalcApplication.ICalcApplication(itsFileType: OSType);
  131.                 { Initializes the Application }
  132.  
  133.                 PROCEDURE TCalcApplication.AboutToLoseControl(convertClipboard: BOOLEAN); OVERRIDE;
  134.                 { Override to reset Edit menu items for incoming DAs }
  135.  
  136.                 FUNCTION TCalcApplication.DoMakeDocument(itsCmdNumber: cmdNumber): TDocument;
  137.                     OVERRIDE;
  138.                 { Launches a TCalcDocument }
  139.  
  140.                 FUNCTION TCalcApplication.MakeViewForAlienClipboard: TView; OVERRIDE;
  141.                 { Handle data that was left in the Clipboard by forces outside the application }
  142.  
  143.                 END;                                    { TCalcApplication }
  144.  
  145. {--------------------------------------------------------------------------------------------------}
  146.             {$IFC qHasForward}
  147.             TCell                = OBJECT;    FORWARD;
  148.             TRow                = OBJECT;    FORWARD;
  149.             TColumn                = OBJECT;    FORWARD;
  150.             TCellsView            = OBJECT;    FORWARD;
  151.             TRowsView            = OBJECT;    FORWARD;
  152.             TColumnsView        = OBJECT;    FORWARD;
  153.             TEntryView            = OBJECT;    FORWARD;
  154.             TCoordView            = OBJECT;    FORWARD;
  155.             {$EndC}
  156.  
  157.             TCalcDocument        = OBJECT (TDocument)
  158.  
  159.                 fCells:             ARRAY [1..kMaxRows, 1..kMaxColumns] OF TCell;
  160.                 fEditCell:            TCell;                { the cell being edited (the current
  161.                                                          selection) }
  162.  
  163.                 fRows:                ARRAY [1..kMaxRows] OF TRow;
  164.                 fRowOffset:         INTEGER;
  165.  
  166.                 fColumns:            ARRAY [1..kMaxColumns] OF TColumn;
  167.                 fColumnOffset:        INTEGER;
  168.                 fColumnIsSelected:    BOOLEAN;            { a column has been selected }
  169.  
  170.                 fCellsView:         TCellsView;         { the view of the cells themselves }
  171.                 fRowsView:            TRowsView;            { the view of the row numbers }
  172.                 fColumnsView:        TColumnsView;        { the view of the column letters }
  173.                 fEntryView:         TEntryView;         { the view for entering/editing cell values
  174.                                                          }
  175.                 fCoordView:         TCoordView;         { the view that shows the selected cell's
  176.                                                          coordinates }
  177.  
  178.                 fDimensions:        Rect;                { the document's dimensions }
  179.                 fInUseBounds:        Rect;                { the area of the document that is in use }
  180.                 fCalcMode:            CalcMode;            { Manual or Automatic recalculation }
  181.                 fAllocatedCells:    INTEGER;            { the number of allocated cells }
  182.                 fAllocatedRows:     INTEGER;            { the number of allocated rows }
  183.                 fAllocatedColumns:    INTEGER;            { the number of allocated columns }
  184.  
  185.                 fSelectionType:     TypeOfSelection;
  186.  
  187.                 fEditRow:            RowNumber;            { the row of the cell being edited }
  188.                 fEditColumn:        ColumnNumber;        { the column of the cell being edited }
  189.  
  190.                 fNoOfRows:            INTEGER;            { maximum number of rows }
  191.                 fNoOfColumns:        INTEGER;            { maximum number of columns }
  192.  
  193.                                 { Initialization and termination }
  194.  
  195.                 PROCEDURE TCalcDocument.ICalcDocument(dimensions: Rect);
  196.                 { Initialize the document }
  197.  
  198.                 PROCEDURE TCalcDocument.DoInitialState; OVERRIDE;
  199.                 { Initialize allocation counts }
  200.  
  201.                 PROCEDURE TCalcDocument.DoMakeViews(forPrinting: BOOLEAN); OVERRIDE;
  202.                 { Launch the views which are seen in the document's window }
  203.  
  204.                 PROCEDURE TCalcDocument.Free; OVERRIDE;
  205.                 { Free the document }
  206.  
  207.                 PROCEDURE TCalcDocument.FreeData; OVERRIDE;
  208.                 { Delete the cells, rows, and columns }
  209.  
  210.                 { Filing OVERRIDES }
  211.  
  212.                 PROCEDURE TCalcDocument.DoNeedDiskSpace(VAR dataForkBytes,
  213.                     rsrcForkBytes: LONGINT); OVERRIDE;
  214.                 { Tells how many bytes of disk space will be required to store the
  215.                   data for the document in a file on disk }
  216.  
  217.                 PROCEDURE TCalcDocument.DoRead(aRefNum: INTEGER;
  218.                                                rsrcExists, forPrinting: BOOLEAN); OVERRIDE;
  219.                 { Reads in the data from the disk, when a document is Opened or Reverted }
  220.  
  221.                 PROCEDURE TCalcDocument.DoWrite(aRefNum: INTEGER;
  222.                                                 makingCopy: BOOLEAN); OVERRIDE;
  223.                 { Writes the data to the disk, when a document is Saved }
  224.  
  225.                 { Menu handling }
  226.  
  227.                 PROCEDURE TCalcDocument.DoSetupMenus; OVERRIDE;
  228.                 { Enable menu commands }
  229.  
  230.                 FUNCTION TCalcDocument.DoMenuCommand(aCmdNumber: cmdNumber): TCommand; OVERRIDE;
  231.                 { Handle menu commands }
  232.  
  233.                 { Cell management }
  234.  
  235.                 PROCEDURE TCalcDocument.AddCell(theCell: TCell;
  236.                                                 r: RowNumber;
  237.                                                 c: ColumnNumber);
  238.                 { Add the cell to the document }
  239.  
  240.                 FUNCTION TCalcDocument.CellExists(r: RowNumber;
  241.                                                   c: ColumnNumber): BOOLEAN;
  242.                 { Is there a cell object at these coordinates? }
  243.  
  244.                 PROCEDURE TCalcDocument.DeleteCell(r: RowNumber;
  245.                                                    c: ColumnNumber);
  246.                 { Mark the cell at the given coordinates as deleted }
  247.  
  248.                 PROCEDURE TCalcDocument.EachExistingCellDo(cellRange: Rect;
  249.                                                            PROCEDURE
  250.                                                            DoToCell(aCell: GridCell));
  251.                 { Perform DoToCell on each cell object in the range }
  252.  
  253.                 PROCEDURE TCalcDocument.EditCell;
  254.                 { Change the formula of the cell being edited to the string in the entry view }
  255.  
  256.                 PROCEDURE TCalcDocument.FreeCell(theCell: TCell);
  257.                 { Free the specified cell object }
  258.  
  259.                 PROCEDURE TCalcDocument.FreeDeletedCells;
  260.                 { Free each cell object that is marked deleted }
  261.  
  262.                 FUNCTION TCalcDocument.GetCell(r: RowNumber;
  263.                                                c: ColumnNumber): TCell;
  264.                 { Return the cell object for the given coordinates. }
  265.  
  266.                 FUNCTION TCalcDocument.GetExistingCell(r: RowNumber;
  267.                                                        c: ColumnNumber): TCell;
  268.                 { Return the cell object or NIL if no cell is allocated for the given coordinates. }
  269.  
  270.                 FUNCTION TCalcDocument.IsAutoCalc: BOOLEAN;
  271.                 { Evaluates fCalcMode = Automatic }
  272.  
  273.                 PROCEDURE TCalcDocument.SetEntry(r: RowNumber;
  274.                                                  c: ColumnNumber);
  275.                 { Set the text in the entry view to the formula in the cell at the given
  276.                   coordinates }
  277.  
  278.                 PROCEDURE TCalcDocument.UndeleteCell(r: RowNumber;
  279.                                                      c: ColumnNumber);
  280.                 { If there is a cell at the given coordinates, mark it undeleted }
  281.  
  282.                 { Row management }
  283.  
  284.                 PROCEDURE TCalcDocument.AddRow(theRow: TRow);
  285.                 { Add the row to the document }
  286.  
  287.                 PROCEDURE TCalcDocument.EachExistingRowDo(PROCEDURE
  288.                                                           DoToCell(aCell: GridCell));
  289.  
  290.                 FUNCTION TCalcDocument.GetRow(r: RowNumber): TRow;
  291.  
  292.                 FUNCTION TCalcDocument.RowExists(r: RowNumber): BOOLEAN;
  293.  
  294.                 { Column management }
  295.  
  296.                 PROCEDURE TCalcDocument.AddColumn(theColumn: TColumn);
  297.                 { Add the column to the document }
  298.  
  299.                 FUNCTION TCalcDocument.ColumnExists(c: ColumnNumber): BOOLEAN;
  300.  
  301.                 PROCEDURE TCalcDocument.EachExistingColumnDo(PROCEDURE
  302.                                                              DoToCell(aCell: GridCell));
  303.  
  304.                 FUNCTION TCalcDocument.GetColumn(c: ColumnNumber): TColumn;
  305.  
  306.                 { Ranges of cells }
  307.  
  308.                 FUNCTION TCalcDocument.CellInRange(r: INTEGER;
  309.                                                    c: INTEGER;
  310.                                                    range: Rect): BOOLEAN;
  311.                 { Do the given coordinates fall within the range? }
  312.  
  313.                 PROCEDURE TCalcDocument.ConstrainToUsedCells(VAR cellRange: Rect);
  314.                 { Shrink the range of cells to exclude unallocated cells, if possible }
  315.  
  316.                 PROCEDURE TCalcDocument.DoRecalculate(forceAutomatic: BOOLEAN;
  317.                                                       setDependents: BOOLEAN);
  318.                 { Recalculate all cells if fCalcMode = Automatic, otherwise just selected cells }
  319.  
  320.                 { Inspecting }
  321.  
  322.                 PROCEDURE TCalcDocument.Fields(PROCEDURE
  323.                                                DoToField(fieldName: Str255;
  324.                                                          fieldAddr: Ptr;
  325.                                                          fieldType: INTEGER)); OVERRIDE;
  326.  
  327.                 END;                                    { TCalcDocument }
  328.  
  329. {--------------------------------------------------------------------------------------------------}
  330.  
  331.             TCalcWindow         = OBJECT (TWindow)
  332.  
  333.                 PROCEDURE TCalcWindow.IRes(itsDocument: TDocument;
  334.                                            itsSuperView: TView;
  335.                                            VAR itsParams: Ptr); OVERRIDE;
  336.                 { Create the window from a resource template}
  337.  
  338.                 PROCEDURE TCalcWindow.Draw(area: Rect); OVERRIDE;
  339.  
  340.                 END;                                    { TCalcWindow }
  341.  
  342. {--------------------------------------------------------------------------------------------------}
  343.  
  344.             TCellsView            = OBJECT (TTextGridView)
  345.             { TCellsView is the view used to show the cell values. }
  346.  
  347.                 fCalcDocument:        TCalcDocument;
  348.                 fLastOptionKey:        BOOLEAN;            { TRUE if option key down at last idle.
  349.                                                         helps in tracking modifier keys for views
  350.                                                         that care. }
  351.  
  352.                                 { Initialization and termination }
  353.  
  354.                 PROCEDURE TCellsView.ICellsView(itsDocument: TCalcDocument;
  355.                                                 forClipboard: BOOLEAN;
  356.                                                 itsParent: TView);
  357.                 { Initialize the view }
  358.  
  359.                 PROCEDURE TCellsView.IRes(itsDocument: TDocument;
  360.                                           itsSuperView: TView;
  361.                                           VAR itsParams: Ptr); OVERRIDE;
  362.                 { Create the view from a resource template}
  363.  
  364.                 { Commands and menus }
  365.  
  366.                 FUNCTION TCellsView.DoMouseCommand(VAR themouse: Point;
  367.                                                    VAR info: EventInfo;
  368.                                                    VAR hysteresis: Point): TCommand; OVERRIDE;
  369.  
  370.                 PROCEDURE TCellsView.DoSetupMenus; OVERRIDE;
  371.  
  372.                 FUNCTION TCellsView.DoMenuCommand(aCmdNumber: cmdNumber): TCommand; OVERRIDE;
  373.                 { Handle menu commands }
  374.  
  375.                 FUNCTION TCellsView.DoKeyCommand(ch: Char;
  376.                                                  aKeyCode: INTEGER;
  377.                                                  VAR info: EventInfo): TCommand; OVERRIDE;
  378.  
  379.                 { Display and Selection }
  380.  
  381.                 PROCEDURE TCellsView.AdornCol(aCol: INTEGER;
  382.                                               area: Rect); OVERRIDE;
  383.                 { Draw a column delimiter ("adornment") in the given area }
  384.  
  385.                 PROCEDURE TCellsView.AdornRow(aRow: INTEGER;
  386.                                               area: Rect); OVERRIDE;
  387.                 { Draw a row delimiter in the given area }
  388.  
  389.                 FUNCTION TCellsView.DoIdle(phase: IdlePhase): BOOLEAN; OVERRIDE;
  390.                 { Checks the state of the option key and decides whether to make the cursor
  391.                 need to be reset.  We used to use gAlwaysTrackCursor, but this is better. }
  392.  
  393.                 FUNCTION TCellsView.DoSetCursor(localPoint: Point;
  394.                                                 cursorRgn: RgnHandle): BOOLEAN; OVERRIDE;
  395.  
  396.                 PROCEDURE TCellsView.DrawCell(aCell: GridCell;
  397.                                               aQDRect: Rect); OVERRIDE;
  398.                 { Draw the cell's value, using the proper justification }
  399.  
  400.                 PROCEDURE TCellsView.GetVisibleCells(VAR visibleCells: Rect);
  401.                 { Return a rectangle giving the cells that are visible }
  402.  
  403.                 FUNCTION TCellsView.IsCellVisible(aCell: GridCell): BOOLEAN;
  404.                 { Tell whether the specified cell is visible or not }
  405.  
  406.                 PROCEDURE TCellsView.PositionAtCell(aCell: GridCell);
  407.                 { Redraw the views so that aCell is at the top left corner of the grid }
  408.  
  409.                 PROCEDURE TCellsView.ReSelect(cellRegion: RgnHandle);
  410.                 { Set the current selection to the given cells }
  411.  
  412.                 PROCEDURE TCellsView.ReSelectCell(aCell: GridCell);
  413.                 { Set the current selection to the given cell }
  414.  
  415.                 PROCEDURE TCellsView.ScrollSelectionIntoView(redraw: BOOLEAN); OVERRIDE;
  416.                 { Scroll so that at least the top left cell of the selection is visible }
  417.  
  418.                 PROCEDURE TCellsView.SetCell(aCell: GridCell);
  419.  
  420.                 PROCEDURE TCellsView.SetSelection(cellsToSelect: RgnHandle;
  421.                                                   extendSelection, highlight,
  422.                     select: BOOLEAN); OVERRIDE;
  423.                 { Set the current selections to the specified cells. Adjust the entry and
  424.                   coordinate views accordingly. }
  425.  
  426.                 { Printing OVERRIDES }
  427.  
  428.                 FUNCTION TCellsView.DoBreakFollowing(vhs: VHSelect;
  429.                                                      prevBreak: VCoordinate;
  430.                                                      VAR Automatic: BOOLEAN): VCoordinate; OVERRIDE;
  431.  
  432.                 {$IFC qDebug}
  433.                 PROCEDURE TCellsView.DoDrawPageBreak(vhs: VHSelect;
  434.                                                      whichBreak: INTEGER;
  435.                                                      loc: VCoordinate;
  436.                                                      Automatic: BOOLEAN); OVERRIDE;
  437.                 { For debugging printing only, draw lines showing the page breaks. }
  438.                 {$ENDC}
  439.  
  440.                 PROCEDURE TCellsView.GetPrintExtent(VAR printExtent: VRect); OVERRIDE;
  441.                 { Return the area to print, depending on whether the command was Print Selection
  442.                   or Print. }
  443.  
  444.                 { Clipboard handling }
  445.  
  446.                 FUNCTION TCellsView.ContainsClipType(aType: ResType): BOOLEAN; OVERRIDE;
  447.  
  448.                 PROCEDURE TCellsView.WriteCalcScrap(calcScrap: Handle);
  449.  
  450.                 PROCEDURE TCellsView.WriteTextScrap(textScrap: Handle);
  451.  
  452.                 PROCEDURE TCellsView.WriteToDeskScrap; OVERRIDE;
  453.  
  454.                 { Inspecting }
  455.  
  456.                 PROCEDURE TCellsView.Fields(PROCEDURE
  457.                                             DoToField(fieldName: Str255;
  458.                                                       fieldAddr: Ptr;
  459.                                                       fieldType: INTEGER)); OVERRIDE;
  460.  
  461.                 END;                                    { TCellsView }
  462.  
  463. {--------------------------------------------------------------------------------------------------}
  464.             TRowsView            = OBJECT (TTextGridView)
  465.             { TRowsView is the view used to show the row numbers. Click in this view
  466.               to select an entire row or group of rows. }
  467.  
  468.                 fCalcDocument:        TCalcDocument;
  469.  
  470.                 PROCEDURE TRowsView.IRes(itsDocument: TDocument;
  471.                                          itsSuperView: TView;
  472.                                          VAR itsParams: Ptr); OVERRIDE;
  473.                 { Create the view from a resource template}
  474.  
  475.                 PROCEDURE TRowsView.AdornRow(aRow: INTEGER;
  476.                                              area: Rect); OVERRIDE;
  477.                 { Draw a row delimiter in the given area }
  478.  
  479.                 FUNCTION TRowsView.DoMouseCommand(VAR themouse: Point;
  480.                                                   VAR info: EventInfo;
  481.                                                   VAR hysteresis: Point): TCommand; OVERRIDE;
  482.  
  483.                 FUNCTION TRowsView.DoSetCursor(localPoint: Point;
  484.                                                cursorRgn: RgnHandle): BOOLEAN; OVERRIDE;
  485.  
  486.                 PROCEDURE TRowsView.DrawCell(aCell: GridCell;
  487.                                              aQDRect: Rect); OVERRIDE;
  488.  
  489.                 PROCEDURE TRowsView.Fields(PROCEDURE
  490.                                            DoToField(fieldName: Str255;
  491.                                                      fieldAddr: Ptr;
  492.                                                      fieldType: INTEGER)); OVERRIDE;
  493.  
  494.                 END;                                    { TRowsView }
  495.  
  496. {--------------------------------------------------------------------------------------------------}
  497.             TColumnsView        = OBJECT (TTextGridView)
  498.             { TColumnsView is used to show the column headers, represented by the letters
  499.               A-BL. Click in this view to select an entire column or group of columns. }
  500.  
  501.                 fCalcDocument:        TCalcDocument;
  502.  
  503.                 PROCEDURE TColumnsView.IRes(itsDocument: TDocument;
  504.                                             itsSuperView: TView;
  505.                                             VAR itsParams: Ptr); OVERRIDE;
  506.                 { Create the view from a resource template}
  507.  
  508.                 PROCEDURE TColumnsView.AdornCol(aCol: INTEGER;
  509.                                                 area: Rect); OVERRIDE;
  510.                 { Draw a column delimiter in the given area }
  511.  
  512.                 PROCEDURE TColumnsView.CoordToString(coord: INTEGER;
  513.                                                      VAR theString: Str255);
  514.  
  515.                 FUNCTION TColumnsView.DoMouseCommand(VAR themouse: Point;
  516.                                                      VAR info: EventInfo;
  517.                                                      VAR hysteresis: Point): TCommand; OVERRIDE;
  518.  
  519.                 FUNCTION TColumnsView.DoSetCursor(localPoint: Point;
  520.                                                   cursorRgn: RgnHandle): BOOLEAN; OVERRIDE;
  521.  
  522.                 PROCEDURE TColumnsView.DrawCell(aCell: GridCell;
  523.                                                 aQDRect: Rect); OVERRIDE;
  524.  
  525.                 PROCEDURE TColumnsView.Fields(PROCEDURE
  526.                                               DoToField(fieldName: Str255;
  527.                                                         fieldAddr: Ptr;
  528.                                                         fieldType: INTEGER)); OVERRIDE;
  529.  
  530.                 PROCEDURE TColumnsView.ReSelect(cellRegion: RgnHandle);
  531.  
  532.                 END;                                    { TColumnsView }
  533.  
  534. {--------------------------------------------------------------------------------------------------}
  535.             TCalcPrintHandler    = OBJECT (TStdPrintHandler)
  536.  
  537.                 fCmdNumber:         cmdNumber;
  538.  
  539.                 PROCEDURE TCalcPrintHandler.CalcViewPerPage(VAR amtPerPage: VPoint); OVERRIDE;
  540.  
  541.                 FUNCTION TCalcPrintHandler.DoMenuCommand(aCmdNumber: cmdNumber): TCommand; OVERRIDE;
  542.                 { Overridden to handle Print Selection. }
  543.  
  544.                 PROCEDURE TCalcPrintHandler.DoSetupMenus; OVERRIDE;
  545.                 { Overridden to handle Print Selection. }
  546.  
  547.                 END;                                    { TCalcPrintHandler }
  548.  
  549. {--------------------------------------------------------------------------------------------------}
  550.             TEntryView            = OBJECT (TTEView)
  551.             { TEntryView uses TextEdit to display and edit the selected cell's formula. }
  552.  
  553.                 fCalcDocument:        TCalcDocument;
  554.                 fTouched:            BOOLEAN;
  555.                 fTEditing:            BOOLEAN;            { TRUE: TextEdit mode }
  556.                 fFirstEdit:         BOOLEAN;            { TRUE: undo to previous string }
  557.                 fOldString:         Str255;             { previous string, for undo/redo }
  558.  
  559.                 PROCEDURE TEntryView.IRes(itsDocument: TDocument;
  560.                                           itsSuperView: TView;
  561.                                           VAR itsParams: Ptr); OVERRIDE;
  562.  
  563.                 FUNCTION TEntryView.DoKeyCommand(ch: Char;
  564.                                                  aKeyCode: INTEGER;
  565.                                                  VAR info: EventInfo): TCommand; OVERRIDE;
  566.  
  567.                 FUNCTION TEntryView.DoMakeTypingCommand(ch: Char): TTETypingCommand; OVERRIDE;
  568.                 { Actually returns a TCalcTypingCommand }
  569.  
  570.                 FUNCTION TEntryView.DoMouseCommand(VAR themouse: Point;
  571.                                                    VAR info: EventInfo;
  572.                                                    VAR hysteresis: Point): TCommand; OVERRIDE;
  573.  
  574.                 PROCEDURE TEntryView.DoSetupMenus; OVERRIDE;
  575.  
  576.                 PROCEDURE TEntryView.Draw(area: Rect); OVERRIDE;
  577.  
  578.                 PROCEDURE TEntryView.EditMode(editing: BOOLEAN);
  579.                 { Enter or leave TextEdit mode.  In TextEdit mode (fTEditing=TRUE),
  580.                   the Undo command causes an undo of the latest TextEdit action;
  581.                   in non-TextEdit mode, Undo brings back the previous string (fOldString) }
  582.  
  583.                 PROCEDURE TEntryView.Fields(PROCEDURE
  584.                                             DoToField(fieldName: Str255;
  585.                                                       fieldAddr: Ptr;
  586.                                                       fieldType: INTEGER)); OVERRIDE;
  587.  
  588.                 PROCEDURE TEntryView.GetAsString(VAR theString: Str255);
  589.                 { Return the current text as a string }
  590.  
  591.                 PROCEDURE TEntryView.InstallSelection(wasActive, beActive: BOOLEAN); OVERRIDE;
  592.  
  593.                 PROCEDURE TEntryView.SetEditMode;
  594.                 { Enter TextEdit mode and clear the current text }
  595.  
  596.                 PROCEDURE TEntryView.SetToString(theString: Str255);
  597.                 { Set the current text to theString }
  598.  
  599.                 PROCEDURE TEntryView.SwapStrings;
  600.                 { Exchange the current text with that saved in fOldString }
  601.  
  602.                 END;                                    { TEntryView }
  603.  
  604. {--------------------------------------------------------------------------------------------------}
  605.             TCoordView            = OBJECT (TView)
  606.             { TCoordView is the view used to display the coordinates of the cell which is
  607.               currently selected. }
  608.  
  609.                 fCalcDocument:        TCalcDocument;
  610.  
  611.                 PROCEDURE TCoordView.IRes(itsDocument: TDocument;
  612.                                           itsSuperView: TView;
  613.                                           VAR itsParams: Ptr); OVERRIDE;
  614.  
  615.                 PROCEDURE TCoordView.Draw(area: Rect); OVERRIDE;
  616.                { Draws the view seen in the window.  Every nonblank view MUST override this method }
  617.  
  618.                 PROCEDURE TCoordView.Fields(PROCEDURE
  619.                                             DoToField(fieldName: Str255;
  620.                                                       fieldAddr: Ptr;
  621.                                                       fieldType: INTEGER)); OVERRIDE;
  622.  
  623.                 END;                                    { TCoordView }
  624.  
  625.  
  626. {--------------------------------------------------------------------------------------------------}
  627.             TColumn             = OBJECT (TObject)
  628.  
  629.                 fNumber:            INTEGER;
  630.                 fFormat:            FormatRecord;
  631.                 fOldFormat:         FormatRecord;        { save original format for Undo }
  632.                 fWidth:             INTEGER;
  633.  
  634.                 PROCEDURE TColumn.Initialize; OVERRIDE;
  635.                 { Put the object into a known state from which it may be safely FREEd.
  636.                  (and hopefully a usable state) }
  637.  
  638.                 PROCEDURE TColumn.IColumn(number: INTEGER);
  639.  
  640.                 PROCEDURE TColumn.ReadFromDisk(theRefNum: INTEGER);
  641.  
  642.                 PROCEDURE TColumn.WriteToDisk(theRefNum: INTEGER);
  643.  
  644.                 PROCEDURE TColumn.ReadFromScrap(theScrap: Handle;
  645.                                                 VAR scrapOffset: LONGINT);
  646.  
  647.                 PROCEDURE TColumn.WriteToScrap(theScrap: Handle;
  648.                                                VAR scrapOffset: LONGINT);
  649.  
  650.                 PROCEDURE TColumn.Fields(PROCEDURE DoToField(fieldName: Str255;
  651.                                                              fieldAddr: Ptr;
  652.                                                              fieldType: INTEGER)); OVERRIDE;
  653.  
  654.                 END;                                    { TColumn }
  655.  
  656. {--------------------------------------------------------------------------------------------------}
  657.             TRow                = OBJECT (TObject)
  658.  
  659.                 fNumber:            INTEGER;
  660.  
  661.                 PROCEDURE TRow.Initialize; OVERRIDE;
  662.                 { Put the object into a known state from which it may be safely FREEd.
  663.                  (and hopefully a usable state) }
  664.  
  665.                 PROCEDURE TRow.IRow(number: INTEGER);
  666.  
  667.                 PROCEDURE TRow.ReadFromDisk(theRefNum: INTEGER);
  668.  
  669.                 PROCEDURE TRow.WriteToDisk(theRefNum: INTEGER);
  670.  
  671.                 PROCEDURE TRow.ReadFromScrap(theScrap: Handle;
  672.                                              VAR scrapOffset: LONGINT);
  673.  
  674.                 PROCEDURE TRow.WriteToScrap(theScrap: Handle;
  675.                                             VAR scrapOffset: LONGINT);
  676.  
  677.                 PROCEDURE TRow.Fields(PROCEDURE DoToField(fieldName: Str255;
  678.                                                           fieldAddr: Ptr;
  679.                                                           fieldType: INTEGER)); OVERRIDE;
  680.  
  681.                 END;                                    { TRow }
  682.  
  683. {--------------------------------------------------------------------------------------------------}
  684.             TCell                = OBJECT (TObject)
  685.             { TCell describes one element of the spreadsheet grid. }
  686.                 fDeleted:            BOOLEAN;            { Whether the cell has been deleted }
  687.                 fCalcDocument:        TCalcDocument;        { The document I belong to }
  688.                 fReferences:        TList;                { The cells I reference in my formula }
  689.                 fDependents:        TList;                { The cells that reference me }
  690.  
  691.                 fRow:                RowNumber;            { Which row I'm in }
  692.                 fColumn:            ColumnNumber;        { Which column I'm in }
  693.  
  694.                 fKind:                KindOfCell;         { What kind of cell: text, value, empty,
  695.                                                          error }
  696.                 fError:             EvalResult;         { Error code from my latest evaluation }
  697.                 fEvaluating:        BOOLEAN;            { flag for preventing circular reference
  698.                                                          loops }
  699.                 fCalculating:        BOOLEAN;            { flag for preventing self reference loops }
  700.                 fValue:             ValueType;            { My value represented as a number }
  701.                 fValueString:        ValueString;        { My value represented as a string, for
  702.                                                          display }
  703.                 fFormula:            Str255;             { My contents as typed in by the user }
  704.  
  705.                 PROCEDURE TCell.Initialize; OVERRIDE;
  706.                 { Put the object into a known state from which it may be safely FREEd.
  707.                  (and hopefully a usable state) }
  708.  
  709.                 PROCEDURE TCell.ICell(owningDocument: TCalcDocument;
  710.                                       r: RowNumber;
  711.                                       c: ColumnNumber);
  712.                 { Initialize the cell's fields }
  713.  
  714.                 FUNCTION TCell.Clone: TObject; OVERRIDE;
  715.                 { Create a new cell which is a copy of this cell, except for dependents and
  716.                   references }
  717.  
  718.                 PROCEDURE TCell.CopyContents(sourceCell: TCell);
  719.                 { Copy contents of sourceCell }
  720.  
  721.                 PROCEDURE TCell.Free; OVERRIDE;
  722.                 { Free my lists and then free me }
  723.  
  724.                 PROCEDURE TCell.EvaluateFormula(DoReferences: BOOLEAN);
  725.                 { Calculate my value by evaluating fFormula. If DoReferences is TRUE, add any
  726.                   cell references in my formula to the fReferences list, and add me to that
  727.                   cell's fDependents list. }
  728.  
  729.                 PROCEDURE TCell.GetAsString(VAR theString: Str255);
  730.                 { Return my formula string }
  731.  
  732.                 PROCEDURE TCell.GetValueAsString(VAR theString: Str255);
  733.                 { Return a string representation of my value }
  734.  
  735.                 PROCEDURE TCell.invalidate;
  736.                 { Cause a cell to be marked invalid (in need of re-drawing). }
  737.  
  738.                 FUNCTION TCell.IsEmpty: BOOLEAN;
  739.                 { Return TRUE if I have no formula or value }
  740.  
  741.                 PROCEDURE TCell.SetDeleteState(deleted: BOOLEAN);
  742.                 { Mark a cell as deleted or not deleted }
  743.  
  744.                 PROCEDURE TCell.SetToString(theString: Str255);
  745.                 { Set my formula to theString and recalculate my value if necessary }
  746.  
  747.                 PROCEDURE TCell.Recalculate(forceAutomatic: BOOLEAN;
  748.                                             setDependents: BOOLEAN);
  749.                 { Re-evaluate my formula string. If SetDependents is TRUE, put each cell I
  750.                   reference in the fReferences list, and put me on her fDependents list. }
  751.  
  752.                 PROCEDURE TCell.ValueToString;
  753.                 { Fill fValueString with the string representation of my value }
  754.  
  755.                 FUNCTION TCell.GetDiskSize(infoRecordOnly: BOOLEAN): INTEGER;
  756.  
  757.                 PROCEDURE TCell.ReadFromDisk(theRefNum: INTEGER);
  758.  
  759.                 PROCEDURE TCell.WriteToDisk(theRefNum: INTEGER);
  760.  
  761.                 PROCEDURE TCell.ReadFromScrap(theScrap: Handle;
  762.                                               VAR scrapOffset: LONGINT);
  763.  
  764.                 PROCEDURE TCell.WriteToScrap(theScrap: Handle;
  765.                                              VAR scrapOffset: LONGINT);
  766.  
  767.                 { Inspecting }
  768.  
  769.                 PROCEDURE TCell.Fields(PROCEDURE DoToField(fieldName: Str255;
  770.                                                            fieldAddr: Ptr;
  771.                                                            fieldType: INTEGER)); OVERRIDE;
  772.  
  773.                 PROCEDURE TCell.GetInspectorName(VAR inspectorName: Str255); OVERRIDE;
  774.  
  775.                 END;                                    { TCell }
  776.  
  777. {--------------------------------------------------------------------------------------------------}
  778.             TCalcSelectCommand    = OBJECT (TCellSelectCommand)
  779.             { TCalcSelectCommand is a command object created to handle mouse movement when you
  780.               click in a TCellsView. }
  781.  
  782.                 fCalcDocument:        TCalcDocument;
  783.  
  784.                 PROCEDURE TCalcSelectCommand.ICalcSelectCommand(itsDocument: TCalcDocument;
  785.                                                                 itsView: TGridView;
  786.                                                                 theShiftKey, theCmdKey: BOOLEAN);
  787.  
  788.                 PROCEDURE TCalcSelectCommand.ComputeNewSelection(VAR clickedCell: GridCell);
  789.                     OVERRIDE;
  790.  
  791.                 END;                                    { TCalcSelectCommand }
  792.  
  793. {--------------------------------------------------------------------------------------------------}
  794.             TRowSelector        = OBJECT (TCalcSelectCommand)
  795.             { TRowSelector is a command object created to handle mouse movement when you click
  796.               in a TRowsView. }
  797.  
  798.                 fCellSelector:        TCalcSelectCommand; { command to handle cells view selection }
  799.  
  800.                 PROCEDURE TRowSelector.IRowSelector(itsDocument: TCalcDocument;
  801.                                                     itsView: TGridView;
  802.                                                     theShiftKey, theCmdKey: BOOLEAN);
  803.                 { Create a TCalcSelectCommand to handle selection in the cells view in parallel
  804.                   with selection in our view, the rows view }
  805.  
  806.                 PROCEDURE TRowSelector.Free; OVERRIDE;
  807.                 { Dispose of our cell selector }
  808.  
  809.                 PROCEDURE TRowSelector.ComputeAnchorCell(VAR clickedCell: GridCell); OVERRIDE;
  810.                 PROCEDURE TRowSelector.ComputeNewSelection(VAR clickedCell: GridCell); OVERRIDE;
  811.                 PROCEDURE TRowSelector.DoIt; OVERRIDE;
  812.                 { Perform these operations for the cells view as well as for the rows view }
  813.  
  814.                 FUNCTION TRowSelector.TrackMouse(aTrackPhase: TrackPhase;
  815.                                                  VAR anchorPoint, previousPoint, nextPoint: VPoint;
  816.                                                  mouseDidMove: BOOLEAN): TCommand; OVERRIDE;
  817.  
  818.                 END;                                    { TRowSelector }
  819.  
  820. {--------------------------------------------------------------------------------------------------}
  821.             TColumnSelector     = OBJECT (TCalcSelectCommand)
  822.             { TColumnSelector is a command object created to handle mouse movement when you
  823.               click in a TColumnsView. }
  824.  
  825.                 fCellSelector:        TCalcSelectCommand; { command to handle cells view selection }
  826.  
  827.                 PROCEDURE TColumnSelector.IColumnSelector(itsDocument: TCalcDocument;
  828.                                                           itsView: TGridView;
  829.                                                           theShiftKey, theCmdKey: BOOLEAN);
  830.                 { Create a TCalcSelectCommand to handle selection in the cells view in parallel with
  831.                   selection in our view, the column headers }
  832.  
  833.                 PROCEDURE TColumnSelector.Free; OVERRIDE;
  834.                 { Dispose of our cell selector }
  835.  
  836.                 PROCEDURE TColumnSelector.ComputeAnchorCell(VAR clickedCell: GridCell); OVERRIDE;
  837.                 PROCEDURE TColumnSelector.ComputeNewSelection(VAR clickedCell: GridCell); OVERRIDE;
  838.                 PROCEDURE TColumnSelector.DoIt; OVERRIDE;
  839.                 { Perform these operations for the cells view as well as for the column headers }
  840.  
  841.                 FUNCTION TColumnSelector.TrackMouse(aTrackPhase: TrackPhase;
  842.                                                     VAR anchorPoint, previousPoint,
  843.                                                     nextPoint: VPoint;
  844.                                                     mouseDidMove: BOOLEAN): TCommand; OVERRIDE;
  845.  
  846.                 END;                                    { TColumnSelector }
  847.  
  848. {--------------------------------------------------------------------------------------------------}
  849.             TColumnFormatter    = OBJECT (TCommand)
  850.             { TColumnFormatter is a command object created to change the style or justification
  851.               of a column. It is not undoable. }
  852.  
  853.                 fCalcDocument:        TCalcDocument;
  854.                 fSelection:         RgnHandle;            { columns selected for formatting }
  855.  
  856.                 PROCEDURE TColumnFormatter.IFormatter(itsDocument: TCalcDocument;
  857.                                                       itsCommand: INTEGER);
  858.  
  859.                 PROCEDURE TColumnFormatter.Free; OVERRIDE;
  860.  
  861.                 PROCEDURE TColumnFormatter.DoIt; OVERRIDE;
  862.                 PROCEDURE TColumnFormatter.UndoIt; OVERRIDE;
  863.                 PROCEDURE TColumnFormatter.RedoIt; OVERRIDE;
  864.  
  865.                 PROCEDURE TColumnFormatter.Fields(PROCEDURE
  866.                                                   DoToField(fieldName: Str255;
  867.                                                             fieldAddr: Ptr;
  868.                                                             fieldType: INTEGER)); OVERRIDE;
  869.  
  870.                 END;                                    { TColumnFormatter }
  871.  
  872. {--------------------------------------------------------------------------------------------------}
  873.             TColumnSizer        = OBJECT (TCommand)
  874.             { TColumnSizer is a command object created to handle mouse movement when you click
  875.               on the boundary between two columns. }
  876.  
  877.                 fCalcDocument:        TCalcDocument;
  878.                 fCellsView:         TCellsView;
  879.                 fLeftEdge:            INTEGER;
  880.  
  881.                 fColumn:            TColumn;
  882.                 fNewWidth:            INTEGER;
  883.                 fOldWidth:            INTEGER;            { remember previous width for Undo }
  884.  
  885.                 PROCEDURE TColumnSizer.IColumnSizer(itsDocument: TCalcDocument;
  886.                                                     c: ColumnNumber);
  887.  
  888.                 FUNCTION TColumnSizer.TrackMouse(aTrackPhase: TrackPhase;
  889.                                                  VAR anchorPoint, previousPoint, nextPoint: VPoint;
  890.                                                  mouseDidMove: BOOLEAN): TCommand; OVERRIDE;
  891.  
  892.                 PROCEDURE TColumnSizer.TrackFeedback(anchorPoint, nextPoint: VPoint;
  893.                                                      turnItOn, mouseDidMove: BOOLEAN); OVERRIDE;
  894.  
  895.                 PROCEDURE TColumnSizer.TrackConstrain(anchorPoint, previousPoint: VPoint;
  896.                                                       VAR nextPoint: VPoint); OVERRIDE;
  897.  
  898.                 PROCEDURE TColumnSizer.DoIt; OVERRIDE;
  899.  
  900.                 PROCEDURE TColumnSizer.UndoIt; OVERRIDE;
  901.  
  902.                 PROCEDURE TColumnSizer.RedoIt; OVERRIDE;
  903.  
  904.                 PROCEDURE TColumnSizer.SetColumnWidth(newWidth: INTEGER);
  905.  
  906.                 PROCEDURE TColumnSizer.Fields(PROCEDURE
  907.                                               DoToField(fieldName: Str255;
  908.                                                         fieldAddr: Ptr;
  909.                                                         fieldType: INTEGER)); OVERRIDE;
  910.  
  911.                 END;                                    { TColumnSizer }
  912.  
  913. {--------------------------------------------------------------------------------------------------}
  914.             TCalcTypingCommand    = OBJECT (TTETypingCommand)
  915.             { We define our own typing command in order to remember which cell the typing was
  916.               performed in. Then if the user makes another selection we can undo/redo the
  917.               correct cell. }
  918.  
  919.                 fCellsView:         TCellsView;
  920.                 fTargetCell:        GridCell;            { cell selected when command was created }
  921.  
  922.                 PROCEDURE TCalcTypingCommand.ITETypingCommand(itsTEView: TTEView;
  923.                                                               itsFirstChar: Char); OVERRIDE;
  924.                 { Initialize the command object. Save the current cell selection for later
  925.                   Undo/Redo }
  926.  
  927.                 PROCEDURE TCalcTypingCommand.AddCharacter(aChar: Char); OVERRIDE;
  928.                 { Overridden to keep text visible when it overflows the entry view's box }
  929.  
  930.                 PROCEDURE TCalcTypingCommand.UndoIt; OVERRIDE;
  931.                 { Undo the typing in the target cell }
  932.  
  933.                 PROCEDURE TCalcTypingCommand.RedoIt; OVERRIDE;
  934.                 { Redo the typing in the target cell }
  935.  
  936.                 PROCEDURE TCalcTypingCommand.Fields(PROCEDURE
  937.                                                     DoToField(fieldName: Str255;
  938.                                                               fieldAddr: Ptr;
  939.                                                               fieldType: INTEGER)); OVERRIDE;
  940.  
  941.                 END;                                    { TCalcTypingCommand }
  942.  
  943. {--------------------------------------------------------------------------------------------------}
  944.             TCellEditCommand    = OBJECT (TCommand)
  945.             { TCellEditCommand is a command object created to handle the cCopy, cCut, and cClear
  946.               menu commands. }
  947.  
  948.                 fCalcDocument:        TCalcDocument;
  949.                 fSelection:         RgnHandle;            { cells selected when command was created }
  950.  
  951.                 PROCEDURE TCellEditCommand.ICellEditCommand(itsDocument: TCalcDocument;
  952.                                                             itsCommand: INTEGER);
  953.                 { Initialize the command object. Save the current cell selection for later
  954.                   Undo/Redo }
  955.  
  956.                 PROCEDURE TCellEditCommand.Free; OVERRIDE;
  957.                 { Clean up our stuff }
  958.  
  959.                 PROCEDURE TCellEditCommand.DoIt; OVERRIDE;
  960.                 { Edit the currently selected cells }
  961.  
  962.                 PROCEDURE TCellEditCommand.UndoIt; OVERRIDE;
  963.                 { Undo the edit of the cells }
  964.  
  965.                 PROCEDURE TCellEditCommand.RedoIt; OVERRIDE;
  966.                 { Redo the edit of the cells }
  967.  
  968.                 PROCEDURE TCellEditCommand.Commit; OVERRIDE;
  969.                 { Commit the edit of the cells }
  970.  
  971.                 PROCEDURE TCellEditCommand.CopySelection;
  972.                 { Copy the currently selected cell(s) into the clipboard }
  973.  
  974.                 PROCEDURE TCellEditCommand.DeleteSelection;
  975.                 { Delete the currently selected cell(s) }
  976.  
  977.                 PROCEDURE TCellEditCommand.RestoreSelection;
  978.                 { Restore the deleted cells }
  979.  
  980.                 PROCEDURE TCellEditCommand.ReSelect;
  981.                 { Change the selection back to what it was when this command was created }
  982.  
  983.                 PROCEDURE TCellEditCommand.Fields(PROCEDURE
  984.                                                   DoToField(fieldName: Str255;
  985.                                                             fieldAddr: Ptr;
  986.                                                             fieldType: INTEGER)); OVERRIDE;
  987.  
  988.                 END;                                    { TCellEditCommand }
  989.  
  990. {--------------------------------------------------------------------------------------------------}
  991.             TCellPasteCommand    = OBJECT (TCommand)
  992.             { TCellPasteCommand is a command object created to handle the cPaste menu command. }
  993.  
  994.                 fClipDocument:        TCalcDocument;
  995.                 fCalcDocument:        TCalcDocument;
  996.                 fSelection:         RgnHandle;            { cells selected when command was created }
  997.                 fReplacedCells:     TList;                { the cells we pasted over }
  998.  
  999.                 PROCEDURE TCellPasteCommand.ICellPasteCommand(itsDocument: TCalcDocument);
  1000.                 { Initialize the command object }
  1001.  
  1002.                 PROCEDURE TCellPasteCommand.Free; OVERRIDE;
  1003.                 { We don' need this command no more }
  1004.  
  1005.                 PROCEDURE TCellPasteCommand.DoIt; OVERRIDE;
  1006.                 { Paste to the currently selected cells. Save this selection for Undo/Redo. }
  1007.  
  1008.                 PROCEDURE TCellPasteCommand.UndoIt; OVERRIDE;
  1009.                 { Undo the paste of the cells }
  1010.  
  1011.                 PROCEDURE TCellPasteCommand.RedoIt; OVERRIDE;
  1012.                 { Redo the paste of the cells }
  1013.  
  1014.                 PROCEDURE TCellPasteCommand.UpdateViews;
  1015.                 { Redisplay the affected cells }
  1016.  
  1017.                 PROCEDURE TCellPasteCommand.Fields(PROCEDURE
  1018.                                                    DoToField(fieldName: Str255;
  1019.                                                              fieldAddr: Ptr;
  1020.                                                              fieldType: INTEGER)); OVERRIDE;
  1021.  
  1022.                 END;                                    { TCellPasteCommand }
  1023.  
  1024.     IMPLEMENTATION
  1025.         {$I UCalc.inc1.p}
  1026. END.
  1027.